home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet multimedia / Animacje, filmy i prezentacje / Modelowanie 3D / K-3D 0.6.5.0 / k3d-all-in-one-setup-0.6.5.0.exe / aqsis-setup-1.1.0-2006-12-09.exe / include / aqsis / argparse.h < prev    next >
Encoding:
C/C++ Source or Header  |  2005-12-11  |  7.8 KB  |  187 lines
  1. // -*- C++ -*-
  2.  
  3. /* Simple argument-parsing class
  4.  * Copyright (C) 2001 Patrick E. Pelletier <ppelleti@users.sourceforge.net>
  5.  *
  6.  * This program is free software; you can redistribute it and/or modify
  7.  * it under the terms of the GNU General Public License as published by
  8.  * the Free Software Foundation; either version 2 of the License, or
  9.  * (at your option) any later version.
  10.  * 
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  * 
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program; if not, write to the Free Software
  18.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19.  */
  20.  
  21. #ifdef    WIN32
  22. #pragma warning( disable : 4786 )
  23. #endif    // WIN32
  24.  
  25. #include <string>
  26. #include <vector>
  27.  
  28. class ArgParseInternalData;    // hide implementation details
  29.  
  30. /*
  31.  * The ArgParse class allows you to specify names of options
  32.  * that you want parsed, along with a usage message for them.
  33.  * Options come in four flavors: flag, int, float, and string.
  34.  * Flags don't take arguments, but the other kinds do.  For
  35.  * an option that takes an argument, it can be specified with
  36.  * an equals sign, with a colon, or by putting it in the next
  37.  * element of argv.  ("--foo=stuff", "--foo:stuff", or
  38.  * "--foo stuff", respectively)
  39.  *
  40.  * The flavors that take arguments also come in array flavors.
  41.  * With an array, you specify a pointer to a vector of the basic
  42.  * type, instead of just a pointer to a basic type.  This allows
  43.  * the option to appear more than once, and the new values are
  44.  * appended to the array.  Optionally, you can also specify a
  45.  * separator character, so that multiple array elements can be
  46.  * parsed up from a single instance of the option.
  47.  *
  48.  * Options can start with either a single dash or a double dash,
  49.  * but see allowOneCharOptionsToBeCombined() for more information.
  50.  *
  51.  * The argument "--" all by itself signals the end of the options,
  52.  * and everything after it will go into the leftovers (see leftovers())
  53.  * even if it starts with a dash.
  54.  *
  55.  * The usage text for an option gets appended immediately after the
  56.  * name of the option and its aliases.  The ASCII BEL character (\a)
  57.  * can be used as a special kind of tab, which moves the cursor to
  58.  * the current indent level (see usageHeader()), to make it easy to
  59.  * make things line up in columns.
  60.  */
  61.  
  62. /*
  63.  * Rationale for some design decisions:
  64.  *
  65.  * Things which need to be modified are passed as pointers, not as
  66.  * references, because some people feel that non-const references make
  67.  * what's going on less clear, and I kind of agree with them.
  68.  *
  69.  * Arrays are explicitly passed as std::vector (or whatever you change
  70.  * the typedefs below to) instead of passing around iterators and
  71.  * allowing any STL container to be used, just because unnecessary
  72.  * templatization can be less clear and sometimes leads to portability
  73.  * and debugability issues, and doesn't seem justified for this simple
  74.  * application.
  75.  */
  76.  
  77. class ArgParse
  78. {
  79.     public:
  80.         // Basic types: ArgParse always uses these typedefs, so that there's
  81.         // just one place to change things if you want to use float instead
  82.         // of double, or CqString instead of std::string, etc.
  83.         typedef bool apflag;
  84.         typedef int apint;
  85.         typedef double apfloat;
  86.         typedef std::string apstring;
  87.  
  88.         // Array types: ditto
  89.         typedef std::vector<apint> apintvec;
  90.         typedef std::vector<apfloat> apfloatvec;
  91.         typedef std::vector<apstring> apstringvec;
  92.  
  93.         // These two constants are valid values for the "separator"
  94.         // argument to argInts, argFloats, and argStrings.  (Any ASCII
  95.         // character is also a valid argument.)  SEP_NONE means that the
  96.         // only way to get more than one thing in the array is to specify
  97.         // the option more than once.  (e. g. "--foo one --foo two")
  98.         // SEP_ARGV means that each element of argv, up to the next option,
  99.         // will be put into the array.  (e. g. "--foo one two")  Using an
  100.         // ASCII character means that only one argv element is used, but
  101.         // it can become multiple elements in the array by being split
  102.         // on the given character.  (e. g. "--foo one,two")
  103.         enum {
  104.             SEP_NONE = -1,
  105.             SEP_ARGV = -2
  106.     };
  107.  
  108.         ArgParse();
  109.         ~ArgParse();
  110.  
  111.         // Calling this method means that "-bar" will be treated as if
  112.         // it was "-b -a -r", and to specify a multi-character option,
  113.         // you need to use a double dash.  (e. g. "--bar")  If you don't
  114.         // call this method, then single dash and double dash are treated
  115.         // the same.
  116.         void allowOneCharOptionsToBeCombined(); // long but descriptive :)
  117.  
  118.         // Normally, parse() will return an error if there are any
  119.         // unrecognized options.  But if you call this method before
  120.         // calling parse(), then unrecognized options will go into
  121.         // the leftovers, without causing an error.
  122.         void allowUnrecognizedOptions();
  123.  
  124.         // "--foo" will set *value to true.  If allow_negation is true,
  125.         // then "--nofoo" will set *value to false.
  126.         void argFlag(apstring name, apstring usage,
  127.                      apflag* value, bool allow_negation = true);
  128.  
  129.         void argInt(apstring name, apstring usage, apint* value);
  130.         void argInts(apstring name, apstring usage,
  131.                      apintvec* values, int separator = SEP_NONE, int count = -1);
  132.  
  133.         void argFloat(apstring name, apstring usage, apfloat* value);
  134.         void argFloats(apstring name, apstring usage,
  135.                        apfloatvec* values, int separator = SEP_NONE, int count = -1);
  136.  
  137.         void argString(apstring name, apstring usage, apstring* value);
  138.         void argStrings(apstring name, apstring usage,
  139.                         apstringvec* values, int separator = SEP_NONE, int count = -1);
  140.  
  141.         // Makes "aliasname" work just like "realname".  Note that
  142.         // "realname" can be a negated flag name (if the flag allows
  143.         // negation), so you can make "--fooless" mean "--nofoo", for
  144.         // example.
  145.         void alias(apstring realname, apstring aliasname);
  146.  
  147.         // This inserts literal text into the usage message.  The order
  148.         // is significant with respect to calls to argFlag, argInt, etc.
  149.         // The most common use of this would be to add the
  150.         // "Usage: blech [options] files" at the top, but it can also be
  151.         // used to make different "sections" of options (give the --help
  152.         // option to GNU tar to see what I mean) or to make a footer at the
  153.         // end of the usage.  Your string can contain newlines, but it
  154.         // shouldn't end in a newline unless you want an extra blank line.
  155.         // The "indent" value specifies how to line up
  156.         // columns of individual usage messages in the follow section.
  157.         // (Again, refer to the GNU tar usage message to see what I mean.)
  158.         void usageHeader(apstring text, int indent = 25);
  159.  
  160.         // This makes the parsing actually happen.  Returns true on
  161.         // success, or false on failure.
  162.         bool parse(int argc, const char** argv);
  163.  
  164.         // If parse() returns false, this method will give you an
  165.         // error message that describes what's wrong.  Note that
  166.         // although it's legal to call parse() more than once on the
  167.         // same ArgParse object, only the most recent error message is
  168.         // retained.
  169.         apstring errmsg() const;
  170.  
  171.         // Returns a usage string made up of the usage messages of
  172.         // the individual arguments, with things from usageHeader()
  173.         // interspersed at the appropriate places.  The string returned
  174.         // contains embedded newlines, and also a trailing newline.
  175.         apstring usagemsg() const;
  176.  
  177.         // Returns any leftover arguments.  (arguments which didn't start
  178.         // with a dash and didn't get eaten by another option, or any
  179.         // arguments which appeared after "--")
  180.         // Again, this is only valid until the next call to parse() on
  181.         // this ArgParse object.
  182.         const apstringvec& leftovers() const;
  183.  
  184.     private:
  185.         ArgParseInternalData* d;
  186. };
  187.